The project started with a simple school project, we had to create a 2D game.
I decided to work on a 3D renderer because I already worked on 2D games before and already started to learn about 3D rendering.
The first version of NRE is a simple voxel renderer capable of rendering a basic world :

• World generation
• Basic interface
• Event handling

The world is only made of 4 types of voxel, neighbors voxel are merged together.
It permits to render big worlds with great performances :

• Voxel merging
• Frustum culling
• Vertex indexing
• Cubemap rendering
• Up to 85 millions voxels rendering (51x51 chunks)

The engine was firstly designed to play a game for the school project, the world system was a development feature for me.
I named the created game You're not Alone, the player moves in a labyrinth, evading zombies to find treasures showed on a mini-map :

• Light system
• Basic AI
• A* Pathfinding
• Model rendering

The game is pretty basic, but the development was a real source of inspiration for the future of the engine.
Those features were not perfect, some couldn't work with others, like triangle merging couldn't work with light system.
I was using basic OpenGL 3.0 with built-in pipeline.

The end product was an unstable engine capable of doing many unfinished things,
so when I saw what I could achieve with only a keyboard, I didn't want to stop things here.

After the school project, I decided to continue the NRE 0.0
But quickly find it too unstable and filled with unoptimised or dirty code.
So I decided to rewrite the whole engine from scratch :

• Proper event-handling system, with customisable callback
• Advanced use of OpenGL 4.5
• Advanced graphics
• Deferred rendering
• Cleaner code

• Up to 10 millions voxels rendering without optimisation
• Up to 325 millions voxels rendering with optimisation
• Advanced graphics : SSAO, PBR pipeline, Shadow, Normal mapping
• Complex object loading
• Deferred rendering
• Base particle system
• Cleaner code

At a certain state the NRE 1.0 taked the same path as 0.0, lots of unfinished work and a start of unstability in the code.
So for the second time I decided to rewrite it from scratch, and make things properly this time.
All class coded in the engine has been thought before being developped, and as I learned more thins while doing NRE 2.0 I was able to developped something a lot powerful and usable than NRE 1.0.
The 2.0 version is largely more powerful than the 1.0, and clearly more user-friendly.

The main feature from the NRE 2.0 is it's ECS, the Entity-Component-System, allowing the user to create a game interacting with the engine with relative ease.
He can create system reacting with the Event handling system (reworked for the occasion, using Event emitter and handler system), and working on entity's component.
The ECS is based on the EntityX work, so it's powerful, but it has been reworked to fit NRE' need.
As the NRE 1.0 was a big step forward into graphics effect, the 2.0 includes all of them.

The Engine add more customisable features, like Thread manager, dynamic textures loading, model loading, ...

• Customisable 2D or 3D Camera
• PBR Rendering pipeline
• Runtime shader managment
• SSAO, IBL, Bloom, Dynamic shadow, Normal mapping
• Entiy-Component-System
• Fast event handler
• User-friendly application development
• World generator
• Optimized memory allocator
• Optimized mesh reconstruction
• Customisable mesh layout system
• Dynamic texture resolution
• 2D primitive rendering
• Advanced OpenGL wrapper
• ...

At a moment I wanted to know more about basic things in C++, like the standard library which is heavily used in the engine.
So I decided that the best solution to learn more is to reimplement it and try to equals their performance and why not outpass them.
This is when NRE-Math and NRE-Utility became separate APIs. I've decided to fragment the engine into separate APIs usable for the most part in standalone.
NRE-Utility reimplement basic C++ container like Vector, List, Map, ... with performance equal or better than the standard library.
The interface is cloned from the standard one, so when I will switch to NRE-Utility in the engine it will be (nearly) transparent.

When NRE-Utility had a basic set of container (not all of them), I've decided to work another part where I wanted to learn more : SDL implementation
After all, NearlyRealEngine has been created to allow me to learn a lot in programmation, as I've managed to re-implement the standard library, why not do the same with the SDL ?

This is when NRE-System born, an API allowing the user to access basic system functionnality like CPU or memory state, but also graphics and events system.
It takes me a bit of a time to get it working, but currently NRE-System can do what the SDL do in a more restricted way as I only implemented what I really need to get the engine working.

So now I have a lots of APIs allowing me to create the third version of the engine completly from scratch, and also this allow me to build the engine on different OS,
as I designed NRE-System with in mind to create an abstraction layer around the user OS for the engine.

Nothing is done yet, as I'm still separating the engine modules in APIs. But the engine will soon be functionnal again, with a lot of new feature in the future !